#include "datos.h"

using namespace std;


Datos::Datos()
{
    vector <SeePlayer> see;
    SeePlayer seepl;
    for(int i = 0; i<12; i++)
        see.push_back(seepl);
    Seeplayer.assign(3,see);
}

/**
 * @brief Datos::setDatosSee Asignamos los valores de la instrucción See.
 * @param instruccion Contiene el nombre del objeto que vemos.
 * @param valor Vector que contiene los diferentes valores del objeto.
 *
 * La funcion setDatosSee recibe un string con la informacion despues del parseo y distribuye los valores
 * en la clase see. Siempre que reciba un valor recibe tambien la instruccion a la que pertenece para encontrarla
 * en el map.
 */

void Datos::setDatosSee(std::string instruccion, vector<string> valor)
{
    double j;

    string cadena; ///< Variable auxiliar que facilita la conversión de string a double
    if (valor.size()>0){
        for (int i=0; i<valor.size();i++)
        {
           cadena=valor.at(i);
           j=atof(cadena.c_str());
            switch (i)
            {
            case 0:
                Seeinst[instruccion].setDist(j);
                break;
            case 1:
                Seeinst[instruccion].setDir (j);
                break;
            case 2:
                Seeinst[instruccion].setDistchng (j);
                break;
            case 3:
                Seeinst[instruccion].setDirchng (j);
                break;
            case 4:
                Seeinst[instruccion].setBodydir (j);
                break;
            case 5:
                Seeinst[instruccion].setHeaddir (j);
                break;
            }
        }
    }
}


/**
 * @brief Datos::setDatosSeePlayer Asignamos los valores de los jugadores que vemos.
 * @param _equipo Nombre del equipo del jugador.
 * @param _dorsal Número del jugador.
 * @param valor Vector con los valores de posición y velocidad del jugador.
 *
 * La funcion setDatosSeePlayer recibe un string con la informacion del equipo, otro con el dorsal del jugador
 * y un vector con la información que nos otorga el see de cada jugador, y con estos datos
 * crea y modifica el vector donde se almacenan todos los jugadores.
 */

void Datos::setDatosSeePlayer(string _equipo, string _dorsal, vector<string> valor)
{
    double j;
    int equipo, dorsal;

    string cadena; //Variable auxiliar que facilita la conversión de string a double

    if (_equipo.find("desconocido") != string::npos)
        equipo=0;
    else
        if (_equipo.find("Grupo_3") != string::npos)
            equipo=1;
        else
            equipo=2;
    if (_dorsal.find("desconocido") != string::npos)
        dorsal = 0;
    else
        dorsal=atoi(_dorsal.c_str());

    Seeplayer.at(equipo).at(dorsal).setDorsal(dorsal);
    Seeplayer.at(equipo).at(dorsal).setEquipo(equipo);

    if (valor.size()>0)
    {
        for (int i=0; i<valor.size();i++)
        {
            cadena.clear();
            cadena=valor.at(i);
            j=atof(cadena.c_str());
            switch (i)
            {
            case 0:
                Seeplayer.at(equipo).at(dorsal).setDist(j);
                break;
            case 1:
                Seeplayer.at(equipo).at(dorsal).setDir (j);
                break;
            case 2:
                Seeplayer.at(equipo).at(dorsal).setDistchng (j);
                break;
            case 3:
                Seeplayer.at(equipo).at(dorsal).setDirchng (j);
                break;
            }
        }
    }
}

/**
 * @brief Datos::setDatosSense Asignamos los valores de estado del propio jugador
 * @param instruccion Contiene el nombre de la propiedad a evaluar.
 * @param valor Contiene los valores de cada propiedad.
 *
 * La función setDatosSense recibe un string con el nombre de la instrucción y un vector
 * con los datos a guardar. La instrucción es el indicador del map donde se guarda
 * la información para poder encontrarla después.
 */

void Datos::setDatosSense(string instruccion,vector<string> valor)
{

    if (instruccion.compare("view_mode")==0)  //
    {
        Senseinst[instruccion].setQuality (valor[0]);

        Senseinst[instruccion].setWidth (valor[1]);
    }
    else
        Senseinst[instruccion].setValue(valor);

}

/**
 * @brief Datos::setDatosHear Analizamos lo que oyen los jugadores.
 * @param who Emisor del mensaje.
 * @param data
 * @param cadena
 */
void Datos::setDatosHear(string who, vector<string> data,string cadena)
{
    ultimaCadena.clear();
    ultimaCadena=cadena;
    Hearinst[who].setdata(data);
}

/**
 * @brief Datos::setDatosHear
 * @param who
 * @param cadena
 */
void Datos::setDatosHear(string who, string cadena)
{
    vector<string> data;
    data.push_back(cadena);
    data.push_back("");
    ultimaCadena.clear();
    ultimaCadena = cadena;
    Hearinst[who].setdata(data);
}

/**
 * @brief Datos::setCiclo
 * @param _ciclo
 */
void Datos::setCiclo(string _ciclo)
{
    ciclo = atoi(_ciclo.c_str());
}

/**
 * @brief Datos::setTrueHearEvent Ponemos la variable hearEvent a true.
 */
void Datos::setTrueHearEvent()
{
    hearEvent = true;
}
/**
 * @brief Datos::setFalseHearEvent Ponemos la variable hearEvent a false.
 */
void Datos::setFalseHearEvent()
{
    hearEvent = false;
}

/**
 * @brief Datos::setValor Introducimos los valores de la instrucción.
 * @param dato String con el dato a introducir.
 *
 * Introducimos el dato correspondiente al vector valores donde se almacenan todos los datos de
 * una determinada intrucción. Esta función se vital para el parser.
 */
void Datos::setValor (string dato)
{
    valores.push_back(dato);
}

/**
 * @brief Datos::setInit Introducimos los valores iniciales dados por el servidor.
 * @param initData Vector donde se almacenan los valores iniciales.
 *
 * En esta función almacenamos los valores iniciales que nos proporciona el servidor
 * como son el dorsal y el lado del campo en el que jugamos. Si por lo que sea no
 * recibimos ningún lado éste se guardará como "desconocido".
 */
void Datos::setInit(vector<string> initData)
{
    side.clear();
    numero=atoi(initData.at(0).c_str());
    if(initData.at(1) != "l" && initData.at(1) != "r")
        side = "desconocido";
    else
        side = initData.at(1);
}

/**
 * @brief Datos::getNumero
 * @return Devolvemos el número del jugador.
 */
int Datos::getNumero()
{
    return numero;
}

/**
 * @brief Datos::getCiclo
 * @return Devolvemos el número del ciclo.
 */
int Datos::getCiclo()
{
    return ciclo;
}

void Datos::setSide(string _side)
{
    side=_side;
}

string Datos::getSide()
{
    return side;
}

string Datos::getultimaCadena()
{
    return ultimaCadena;
}

SeePlayer Datos::getJugadorPropio(int dorsal)
{
    return Seeplayer.at(1).at(dorsal);
}

SeePlayer Datos::getJugadorContrario(int dorsal)
{
    return Seeplayer.at(2).at(dorsal);
}

SeeVar Datos::getSeeInst(string instruccion)
{
    return Seeinst[instruccion];
}

SenseVar Datos::getSenseInst(string instruccion)
{
    return Senseinst[instruccion];
}

HearVar Datos::getHearInst(string instruccion)
{
    return Hearinst[instruccion];
}
